package cn.edu.scut.hsrc.bean;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import cn.edu.scut.hsrc.bean.WordType.Type;

/**
 * 具有反引用功能的词的定义
 * @file RefWord.java
 * @author feiyu
 *
 */

public class RefWord extends Word implements IRef<Integer, List<Integer>>{
	
	private Map<Integer, List<Integer>> refNodes;	//反引用集合（这里面的引用位置一定时单一的）
													//如果这个类用在全局词集合中，这个保存的是在全局范围内，包含该词的<文档下标，段号>集合
													//如果这个类用在单个文档词集合中，这个保存的是这个词在那个文档中的<段号，段偏移>集合

	/**
	 * 构造函数
	 * @param text	词
	 * @param type	词性
	 * @param relationToQuery	和查询词关系得分
	 * @param key 反引用位置的键值
	 * @param refs 反引用位置的具体值(多个反引用值)
	 */
	public RefWord(String text, Type type, RelationToQuery relationToQuery,Integer key,List<Integer> refs) {
		super(text, type, relationToQuery);
		// TODO Auto-generated constructor stub
		this.refNodes = new HashMap<Integer, List<Integer>>();
		addRef(key,refs);
	}
	
	/**
	 * 构造函数
	 * @param text	词
	 * @param type	词性
	 * @param relationToQuery	和查询词关系得分
	 * @param key 反引用位置的键值
	 * @param ref 反引用位置的具体值(单个反引用值)
	 */
	public RefWord(String text, Type type, RelationToQuery relationToQuery,Integer key,Integer ref) {
		super(text, type, relationToQuery);
		// TODO Auto-generated constructor stub
		this.refNodes = new HashMap<Integer, List<Integer>>();
		List<Integer> refs = new ArrayList<Integer>();
		refs.add(ref);
		addRef(key,refs);
	}
	
	/**
	 * 
	 * 构造函数
	 * @param word	词
	 * @param key 反引用位置的键值
	 * @param ref 反引用位置的具体值
	 */
	public RefWord(Word word,Integer key,List<Integer> ref) {
		// TODO Auto-generated constructor stub
		super(word);
		this.refNodes = new HashMap<Integer, List<Integer>>();
		addRef(key,ref);
	}
	
	@Override
	public Map<Integer, List<Integer>> getRefs() {
		// TODO Auto-generated method stub
		return this.refNodes;
	}
	
	@Override
	public boolean addRef(Integer key, List<Integer> val) {
		// TODO Auto-generated method stub
		if(key == null || key < 0)
			return false;
		List<Integer> refs = this.refNodes.get(key);
		if(refs != null)
		{
			boolean flag = false;
			for (Integer integer : val) {
				if(refs.indexOf(integer) == -1)
				{
					refs.add(integer);
					flag = true;
				}
			}
			this.refNodes.put(key, refs);
			return flag;
		}else {
			this.refNodes.put(key, val);
			return true;
		}
	}

	@Override
	public int addRefs(Map<Integer, List<Integer>> refs) {
		// TODO Auto-generated method stub
		if(refs == null)
			return 0;
		int count = 0;
		Iterator<Map.Entry<Integer, List<Integer>>> iterator = refs.entrySet().iterator();
		while (iterator.hasNext()) {
			Map.Entry<Integer, List<Integer>> entry = iterator.next();
			if(addRef(entry.getKey(), entry.getValue()))
				count++;
		}
		return count;
	}

	@Override
	public void setRefs(Map<Integer, List<Integer>> refs) {
		// TODO Auto-generated method stub
		if(refs == null)
			return;
		this.refNodes = refs;
	}
	
	/**
	 * 这里判断两个词相等，只是判断他们的字符串是否相等
	 */
	@Override
	public boolean equals(Object obj) {
		// TODO Auto-generated method stub
		if(obj instanceof RefWord)
		{
			return super.getText().equals(((RefWord)obj).getText());
		}
		return false;
	}

	@Override
	public String toString() {
		// TODO Auto-generated method stub
		String text = "";
		text += super.getText()+",";
		text += super.getRelationToQuery();
		return text;
	}
}

